/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package proy1sistdistribuidos.modelo;

import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Enumeration;
import java.util.LinkedList;
import java.util.List;
import java.util.Observable;
import java.util.TreeMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import net.jxta.discovery.DiscoveryEvent;
import net.jxta.discovery.DiscoveryListener;
import net.jxta.discovery.DiscoveryService;
import net.jxta.document.Advertisement;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.Document;
import net.jxta.document.MimeMediaType;
import net.jxta.id.ID;
import net.jxta.id.IDFactory;
import net.jxta.impl.id.UUID.PipeID;
import net.jxta.peergroup.PeerGroup;
import net.jxta.peergroup.PeerGroupID;
import net.jxta.pipe.PipeService;
import net.jxta.platform.NetworkManager;
import net.jxta.protocol.PipeAdvertisement;
import proy1sistdistribuidos.control.advertisements.AdvertisementContenidoFisico;
import proy1sistdistribuidos.control.advertisements.AdvertisementContenidoFisicoImpl;
import proy1sistdistribuidos.control.advertisements.AdvertisementImagen;
import proy1sistdistribuidos.control.advertisements.AdvertisementImagenImpl;
import proy1sistdistribuidos.control.advertisements.AdvertisementRecurso;
import proy1sistdistribuidos.control.advertisements.MyAdvertisementRecurso;
import sun.misc.BASE64Encoder;

/**
 * @author Carlos Diaz Maya, Juan Felipe Garcia
 * basado en la misma clase hecha para el Ejemplo JXTA desarrollado por el monitor Alvaro Gomez (alvar-go@uniandes.edu.co)
 * para el uso en este proyecto
 *
 */
public class AdministradorJXTA extends Observable implements DiscoveryListener{

    private final static String RUTA_CACHE = "data/cache";

    private NetworkManager manager;

    private PeerGroup netPeerGroup;

    private DiscoveryService discovery;

    private PipeAdvertisement pipeAdv;

    private String nombreNodo;
    
    private List<AdvertisementImagenImpl> listaImagenFiltroImagen = new ArrayList<AdvertisementImagenImpl>();
    
    private List<AdvertisementImagenImpl> listaImagenFiltroId = new ArrayList<AdvertisementImagenImpl>();
    
    private TreeMap<String,AdvertisementImagenImpl> mapaOrd = new TreeMap<String,AdvertisementImagenImpl>();
    
    private List<AdvertisementContenidoFisicoImpl> listaContFis = new ArrayList<AdvertisementContenidoFisicoImpl>();

    private  AdvertisementContenidoFisicoImpl infoContenidoFisico;

    //private List<NodoRemotoLista> listaResultados = new ArrayList<NodoRemotoLista>();
    
    private Integer idConsulta;
    
    private Long colorEntrada;
    private Long tamanhoEntrada;
    public static final double cotaInferior = 0.5d;
    public static final double cotaSuperior = 1.5d;
    private AdministradorJXTA administrador;
    private List<String[]> personasFiltro;
    private String idEtiquetaObtenerInfo;
    private String etiquetaFiltroEtiqueta;


    public AdministradorJXTA(String nombre) throws Exception{
        nombreNodo = nombre;
        try {
            manager = new NetworkManager(NetworkManager.ConfigMode.ADHOC, nombre, new File(RUTA_CACHE, nombre).toURI());
            manager.startNetwork();
            
            //Registrar advertisements
            AdvertisementFactory.registerAdvertisementInstance(AdvertisementRecurso.getAdvertisementType(), new MyAdvertisementRecurso.Instantiator());
            AdvertisementFactory.registerAdvertisementInstance(AdvertisementContenidoFisico.getAdvertisementType(), new AdvertisementContenidoFisicoImpl.Instantiator());
            AdvertisementFactory.registerAdvertisementInstance(AdvertisementImagen.getAdvertisementType(), new AdvertisementImagenImpl.Instantiator());


            netPeerGroup = manager.getNetPeerGroup();
            PeerGroupID id = netPeerGroup.getPeerGroupID();
            PipeID idPipe = crearPipeID(id);
            pipeAdv = crearPipeAdvertisement(idPipe);
            discovery = netPeerGroup.getDiscoveryService();
            discovery.addDiscoveryListener(this);
        } catch (Exception e) {
            throw new Exception("no fue posible conectarse a la red: \n" + e.getMessage());
        }

        
    }

     private static PipeID crearPipeID(PeerGroupID pgID) {
        PipeID socketID = null;
        try {
            socketID = (PipeID) IDFactory.newPipeID(pgID);
        } catch (Exception ex) {

        }
        return socketID;
    }

    private PipeAdvertisement crearPipeAdvertisement(ID pipeId) {
        PipeAdvertisement advertisement = (PipeAdvertisement) AdvertisementFactory.newAdvertisement(PipeAdvertisement.getAdvertisementType());
        advertisement.setPipeID(pipeId);
        advertisement.setType(PipeService.UnicastType);
        advertisement.setName("Pipe distribuidos");
        return advertisement;
    }

    public void buscarInformacionNodos(){
        this.idConsulta=5;
        discovery.getRemoteAdvertisements(null, DiscoveryService.ADV, MyAdvertisementRecurso.nombreAdvertisementTag, "ExisteNodo", 10, this);
    }

    public void buscarArchivosPorEtiqueta(String etiqueta){
        this.idConsulta=1;
        this.listaImagenFiltroId.clear();
        this.etiquetaFiltroEtiqueta = etiqueta;
        int remoteAdvertisements = discovery.getRemoteAdvertisements(null, DiscoveryService.ADV, AdvertisementImagenImpl.etiquetaNombreAdvertisement, "ExisteImagen", 10, this);
    }

    public void buscarImagenesPorNombresPersonas(List<String[]> pers){
        //TreeMap<String,AdvertisementImagenImpl> mapaOrd = new TreeMap<String,AdvertisementImagenImpl>();
        this.idConsulta = 3;
        this.mapaOrd.clear();
        this.personasFiltro = pers;
      /*  for(String[] per: pers){
            int remoteAdvertisements1 = discovery.getRemoteAdvertisements(null, DiscoveryService.ADV, AdvertisementImagenImpl.etiquetaNombresPersona, per[0], 10, this);
            int remoteAdvertisements2 = discovery.getRemoteAdvertisements(null, DiscoveryService.ADV, AdvertisementImagenImpl.etiquetaApellidosPersona, per[1], 10, this);
        }*/
        int remoteAdvertisements = discovery.getRemoteAdvertisements(null, DiscoveryService.ADV, AdvertisementImagenImpl.etiquetaNombreAdvertisement, "ExisteImagen", 10, this);
        
    }

    public void buscarFotoMasParecidaAImagen(byte[] imagenDada) throws IOException{
        ByteArrayInputStream imEntrada = new ByteArrayInputStream(imagenDada);
        BufferedImage imagenBuf = ImageIO.read(imEntrada);
        int ancho = imagenBuf.getWidth();
            int alto = imagenBuf.getHeight();
            long suma = 0l;
            long cant = 0;
            for(int i = 0; i<ancho; i++){
                for(int j = 0 ; j<alto; j++){
                    int pix = imagenBuf.getRGB(i, j);
                    suma += new Integer(pix).longValue();
                    cant++;
                }
            }
            long colorPromedio = 0l;
            if(cant>0){
                colorPromedio = suma/cant;
            } else {
                colorPromedio = -1l;
            }

            long tamanho = new Integer(imagenDada.length).longValue();

            this.colorEntrada = colorPromedio;
            this.tamanhoEntrada = tamanho;
            
            this.idConsulta = 2;
            this.listaImagenFiltroImagen.clear();
            int remoteadvertisements = discovery.getRemoteAdvertisements(null, DiscoveryService.ADV, AdvertisementImagenImpl.etiquetaNombreAdvertisement, "ExisteImagen", 100, this);

            
            
            
            //for(AdvertisementImagenImpl adv:listBusqImg.getLista()){
               
            //}
    }

    public void obtenerInformacionImagen(String idEtiqueta) {
        this.idConsulta = 4;
        this.idEtiquetaObtenerInfo = idEtiqueta;
        this.infoContenidoFisico = null;
         int remoteadvertisements = discovery.getRemoteAdvertisements(null, DiscoveryService.ADV, AdvertisementContenidoFisicoImpl.etiquetaIdContenidoFisico, idEtiqueta, 10, this);
    }

    public void publicarNodo()throws Exception{
        try {
            MyAdvertisementRecurso adv = new MyAdvertisementRecurso();
            adv.setNombreAdvertisement("ExisteNodo");

            //Se obtiene la ip
            String direccionIp = InetAddress.getLocalHost().getHostAddress().toString();
            if(InetAddress.getLocalHost().isLoopbackAddress()){
                Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
                for (NetworkInterface netint : Collections.list(nets)){
                    if(!netint.isLoopback() && netint.isUp() && !netint.isVirtual()){
                        direccionIp = netint.getInetAddresses().nextElement().getHostAddress().toString();
                        break;
                    }
                }

            }

            
            adv.setDireccionIP(direccionIp);
            adv.setNombreNodo(nombreNodo);
            adv.setPipeAdv(pipeAdv);
            discovery.publish(adv);
        } catch (Exception e) {
            throw new Exception("No se pudó publicar la información del nodo en la red: \n" + e.getMessage());
        }
    }

    public void publicarImagen(String etiqueta, List<String[]> personas, File archivo) throws Exception {
         try {

            //----Inicio codigo creacion hash ----
            //Adaptado del codigo disponible en:
            //http://www.mkyong.com/java/java-sha-hashing-example/
            //para su uso en este proyecto.

            //Se crea un indice SHA-256 con base a la etiqueta
            //
            MessageDigest md = MessageDigest.getInstance("SHA-256");

            byte[] etiquetaEnBytes = etiqueta.getBytes();
            //Se pasa el arreglo al "digester" para que la pase a SHA-256
            md.update(etiquetaEnBytes);

            //Se guarda el resultado en otro arreglo de bytes
            byte[] arrbtDigest = md.digest();


            //Lineas tomadas directamente del ejemplo disponible en
            //http://www.mkyong.com/java/java-sha-hashing-example/
            //donde se pasa el hash a formato hexadecimal
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < arrbtDigest.length; i++) {
                sb.append(Integer.toString((arrbtDigest[i] & 0xff) + 0x100, 16).substring(1));
            }

            String indiceEtiqueta = sb.toString();
            //--- Fin código creación hash

            //Se crea el advertisement del contenido de la imagen
            AdvertisementContenidoFisicoImpl adv1 = new AdvertisementContenidoFisicoImpl();
            adv1.setNombreAdvertisement("ContenidoFisico");
            adv1.setIdContenidoFisico(indiceEtiqueta);

            //Se obtiene mime type y nombre del archivo
            String nombreArchivo = archivo.getName();
            String[] partesArchivo = nombreArchivo.split("\\.");
            if(partesArchivo.length != 2) {
                throw new Exception("Formato de archivo no válido");
            }
            String extensionArchivo = partesArchivo[1];
            if(extensionArchivo.equalsIgnoreCase("png") ||
               extensionArchivo.equalsIgnoreCase("jpg") ||
               extensionArchivo.equalsIgnoreCase("jpeg") ||
               extensionArchivo.equalsIgnoreCase("gif")){
                String tipoMime = null;
                if(extensionArchivo.equalsIgnoreCase("png")){
                    tipoMime = TiposMime.MIMETYPEPNG;
                } else if(extensionArchivo.equalsIgnoreCase("jpg") ||
                          extensionArchivo.equalsIgnoreCase("jpeg")){
                    tipoMime = TiposMime.MIMETYPEJPG;
                } else if(extensionArchivo.equalsIgnoreCase("gif")){
                    tipoMime = TiposMime.MIMETYPEGIF;
                }
                adv1.setMimeTypeArchivoFisico(tipoMime);
            } else {
                throw new Exception("Formato de archivo no válido");
            }
            adv1.setNombreArchivoFisico(archivo.getName());

            //Se obtiene el contenido binario del archivo y se convierte
            //a cadena Base64
            FileInputStream fStream = new FileInputStream(archivo);
            BufferedInputStream buf = new BufferedInputStream(fStream);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();


            byte[] buffer = new byte[1024];

            int bytesLeidos = buf.read(buffer);
            while(bytesLeidos >= 0){
                baos.write(buffer);
                bytesLeidos = buf.read(buffer);
            }

            byte[] archivoArrBytes = baos.toByteArray();

            Long tamArchivoBytes = new Integer(archivoArrBytes.length).longValue();

            BASE64Encoder codifArchivo = new BASE64Encoder();
            String contenidoArchivoBase64 = codifArchivo.encode(archivoArrBytes);
            adv1.setContenidoBase64(contenidoArchivoBase64);



            //Se crea el Advertisement de la informacion asociada de la imagen
            AdvertisementImagenImpl adv = new AdvertisementImagenImpl();
            adv.setNombreAdvertisement("ExisteImagen");
            String direccionIp = InetAddress.getLocalHost().getHostAddress().toString();
            //Ajusta datos del equipo host
            adv.setDireccionIp(direccionIp);
            adv.setNombreNodo(nombreNodo);
            adv.setPipeAdv(pipeAdv);
            
            //Ajusta propiedades de la imagen
            adv.setEtiqueta(etiqueta);
            adv.setIdContenidoFisico(adv1.getIdContenidoFisico());
            //TODO TENGO DUDAS CON ESTE - CEDM
            adv.setIdImagen("i"+adv1.getIdContenidoFisico()); //Se usa el id. del contenidofisico ya que hace uso de la etiqueta
            Date fecha = new Date(System.currentTimeMillis());
            adv.setFechaCreacion(AdvertisementImagen.formato.format(fecha));
            adv.setListaPersonas(personas);
            adv.setTamano(tamArchivoBytes);


            //Se hace el algoritmo para sacar el color "promedio" de la imagen
            ByteArrayInputStream in = new ByteArrayInputStream(archivoArrBytes);
            BufferedImage image = ImageIO.read(in);

            int ancho = image.getWidth();
            int alto = image.getHeight();
            long suma = 0l;
            long cant = 0;
            for(int i = 0; i<ancho; i++){
                for(int j = 0 ; j<alto; j++){
                    int pix = image.getRGB(i, j);
                    suma += new Integer(pix).longValue();
                    cant++;
                }
            }
            long colorPromedio = 0l;
            if(cant>0){
                colorPromedio = suma/cant;
            } else {
                colorPromedio = -1l;
            }
            adv.setColorPromedio(""+colorPromedio);

            adv1.setPipeAdvertisement(pipeAdv);
            discovery.publish(adv1);
            adv.setPipeAdvertisement(pipeAdv);
            discovery.publish(adv);



        } catch (Exception e) {
            throw new Exception("No se pudo publicar la información del nodo en la red: \n" + e.getMessage());
        }
    }

    public void deneterJXTA(){
        manager.stopNetwork();
    }

    public void discoveryEvent(DiscoveryEvent de) {
        Enumeration<Advertisement> respuestas = de.getSearchResults();
        ArrayList<NodoRemoto> nodosEncontrados = new ArrayList<NodoRemoto>();

        while (respuestas.hasMoreElements()){
            Object advertisement = respuestas.nextElement();
            if(advertisement instanceof MyAdvertisementRecurso){
                if(this.idConsulta.intValue() == 5){
                    MyAdvertisementRecurso ad = (MyAdvertisementRecurso)advertisement;
                    if( !ad.getNombreNodo().equals(nombreNodo)){
                        NodoRemoto nr = new NodoRemoto(ad.getDireccionIP(), ad.getNombreNodo());
                        nodosEncontrados.add(nr);
                    }
                }
            }
            else if(advertisement instanceof AdvertisementImagenImpl){
                AdvertisementImagenImpl ad = (AdvertisementImagenImpl)advertisement;

                if(this.idConsulta.intValue()==1){
                    if(ad!=null && ad.getNombreNodo()!=null && !ad.getNombreNodo().equals(nombreNodo) && ad.getEtiqueta().equals(this.etiquetaFiltroEtiqueta)){
                        listaImagenFiltroId.add(ad);
                        break;
                        /*System.out.println("Encontré esto:" + ad.getEtiqueta() + ";" + ((ad.getListaPersonas()!=null&&ad.getListaPersonas().size()>0)?ad.getListaPersonas().get(0):"") +";"+ ad.getIdContenidoFisico());
                        NodoRemotoLista nodo = new NodoRemotoLista();
                        nodo.setNombreEtiqueta(ad.getEtiqueta());
                        nodo.setFechaCreacion(ad.getFechaCreacion());
                        nodo.setFechaDescarga(ad.getFechaDescarga());
                        listaResultados.add(nodo);*/

                    }
                } else if (this.idConsulta.intValue() == 2) {
                    if (ad.getColorPromedio() != null && ad.getTamano() != null) {
                        Long promedioK = Long.parseLong(ad.getColorPromedio());
                        Long tamanhoK = ad.getTamano();

                        Double funcDistancia = ((this.colorEntrada.doubleValue() / promedioK.doubleValue()) + (this.tamanhoEntrada.doubleValue() / tamanhoK.doubleValue())) / 2;

                        if (funcDistancia.doubleValue() >= cotaInferior && funcDistancia.doubleValue() <= cotaSuperior) {
                            if(listaImagenFiltroImagen.size()==0){
                                listaImagenFiltroImagen.add(ad);
                            } else {
                                AdvertisementImagenImpl adv2 = listaImagenFiltroImagen.get(0);
                                Long promedioAdv2 = Long.parseLong(adv2.getColorPromedio());
                                Long tamanhoAdv2 = adv2.getTamano();
                                Double funcDistanciaAdv2 = ((this.colorEntrada.doubleValue() / promedioAdv2.doubleValue()) + (this.tamanhoEntrada.doubleValue() / tamanhoAdv2.doubleValue())) / 2;
                                Double cercaniaAUnoAdv2 = Math.abs(funcDistanciaAdv2-1d);
                                Double cercaniaAUnoImgSel = Math.abs(funcDistancia-1d);

                                if(cercaniaAUnoImgSel<=cercaniaAUnoAdv2){
                                    listaImagenFiltroImagen.clear();
                                    listaImagenFiltroImagen.add(ad);
                                }
                            }
                            System.out.println("color: "+ad.getColorPromedio() + " tamaño:" +ad.getTamano());
                        }
                    }
                     
                } else if (this.idConsulta.intValue() == 3) {
                    for(String[] per: this.personasFiltro){
                        for(String[] perAd:ad.getListaPersonas()){
                            if(per[0].equals(perAd[0]) && per[1].equals(perAd[1])){
                                  mapaOrd.put(ad.etiquetaEtiquetaImagen, ad);
                                  //Se imprime en intrerfaz...
                                  System.out.println("Encontre finalmente esto:");
                                  for(String llave:mapaOrd.keySet()){
                                      System.out.println(mapaOrd.get(llave).getEtiqueta() + " Col:" + mapaOrd.get(llave).getColorPromedio());
                                  }
                            }
                        }
                    }
                }
            }  else if(advertisement instanceof AdvertisementContenidoFisicoImpl){
                AdvertisementContenidoFisicoImpl ad = (AdvertisementContenidoFisicoImpl)advertisement;
                if (this.idConsulta.intValue() == 4) {
                    try {
                        this.infoContenidoFisico = ad;
                        EstadoGeneral estadoGeneral = ControladorEstado.obtenerInstancia().getEstadoLocalDescarga();
                        estadoGeneral.setNombreEstado(estadoGeneral.PROCESAR_DESCARGA);
                        estadoGeneral.setImagenProcesada(ad);
                        estadoGeneral.setMensaje("");
                        ControladorEstado.obtenerInstancia().actualizarEstadoGeneralInicial(estadoGeneral);
                        System.out.println("Info. Archivo fisico:" + ad.getNombreArchivoFisico() + " " + ad.getMimeTypeArchivoFisico());
                    } catch (Exception ex) {
                        Logger.getLogger(AdministradorJXTA.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }
        }

        setChanged();
        
        if (this.idConsulta.intValue() == 1) {
            notifyObservers(listaImagenFiltroId);
        } else if (this.idConsulta.intValue() == 2) {
            try {
                ControladorEstado estado = ControladorEstado.obtenerInstancia();
                EstadoGeneral estadoGeneral = ControladorEstado.obtenerInstancia().getEstadoLocalDescarga();
                estadoGeneral.setNombreEstado(estadoGeneral.PROCESAR_CONSULTA);
                estadoGeneral.setListaResultadosConsulta(listaImagenFiltroImagen);
                ControladorEstado.obtenerInstancia().actualizarEstadoGeneralInicial(estadoGeneral);
                notifyObservers(listaImagenFiltroImagen);
            } catch (Exception ex) {
                Logger.getLogger(AdministradorJXTA.class.getName()).log(Level.SEVERE, null, ex);
            }
        } else if (this.idConsulta.intValue() == 3) {
            notifyObservers(mapaOrd);
        } else if (this.idConsulta.intValue() == 4) {
            notifyObservers(infoContenidoFisico);
        } else if (this.idConsulta.intValue() == 5) {
            try {
                //se guarda en la informacion del estado los nodos encontrados
                ControladorEstado estado = ControladorEstado.obtenerInstancia();
                estado.setListaNodos(nodosEncontrados);
                estado.getEstadoLocalDescarga().setId(estado.obtenerConsecutivoEstado(1).longValue());
                estado.getEstadoLocalDescarga().setNombreEstado(EstadoGeneral.SOLICITAR_PERMISO);
                estado.getEstadoLocalDescarga().setListaNodos(nodosEncontrados);

                 //Se obtiene la ip
                String direccionIp = InetAddress.getLocalHost().getHostAddress().toString();
                if(InetAddress.getLocalHost().isLoopbackAddress()){
                    Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
                    for (NetworkInterface netint : Collections.list(nets)){
                        if(!netint.isLoopback() && netint.isUp() && !netint.isVirtual()){
                            direccionIp = netint.getInetAddresses().nextElement().getHostAddress().toString();
                            break;
                        }
                    }

                }

                estado.getEstadoLocalDescarga().setIdentificadorFuente(direccionIp);
                estado.actualizarEstadoGeneralInicial(estado.getEstadoLocalDescarga());
                notifyObservers(nodosEncontrados);
            } catch (Exception ex) {
                Logger.getLogger(AdministradorJXTA.class.getName()).log(Level.SEVERE, null, ex);
            }

        } else {
            notifyObservers(nodosEncontrados);
        }



    }

    /**
     * @return the listaImagenFiltroImagen
     */
    public List<AdvertisementImagenImpl> getListaImagenFiltroImagen() {
        return listaImagenFiltroImagen;
    }

    /**
     * @param listaImagenFiltroImagen the listaImagenFiltroImagen to set
     */
    public void setListaImagenFiltroImagen(List<AdvertisementImagenImpl> listaImagenFiltroImagen) {
        this.listaImagenFiltroImagen = listaImagenFiltroImagen;
    }

    /**
     * @return the listaImagenFiltroId
     */
    public List<AdvertisementImagenImpl> getListaImagenFiltroId() {
        return listaImagenFiltroId;
    }

    /**
     * @param listaImagenFiltroId the listaImagenFiltroId to set
     */
    public void setListaImagenFiltroId(List<AdvertisementImagenImpl> listaImagenFiltroId) {
        this.listaImagenFiltroId = listaImagenFiltroId;
    }

    /**
     * @return the listaContFis
     */
    public List<AdvertisementContenidoFisicoImpl> getListaContFis() {
        return listaContFis;
    }

    /**
     * @param listaContFis the listaContFis to set
     */
    public void setListaContFis(List<AdvertisementContenidoFisicoImpl> listaContFis) {
        this.listaContFis = listaContFis;
    }

    /**
     * @return the idConsulta
     */
    public Integer getIdConsulta() {
        return idConsulta;
    }

    /**
     * @param idConsulta the idConsulta to set
     */
    public void setIdConsulta(Integer idConsulta) {
        this.idConsulta = idConsulta;
    }

    /**
     * @return the colorEntrada
     */
    public Long getColorEntrada() {
        return colorEntrada;
    }

    /**
     * @param colorEntrada the colorEntrada to set
     */
    public void setColorEntrada(Long colorEntrada) {
        this.colorEntrada = colorEntrada;
    }

    /**
     * @return the tamanhoEntrada
     */
    public Long getTamanhoEntrada() {
        return tamanhoEntrada;
    }

    /**
     * @param tamanhoEntrada the tamanhoEntrada to set
     */
    public void setTamanhoEntrada(Long tamanhoEntrada) {
        this.tamanhoEntrada = tamanhoEntrada;
    }

    /**
     * @return the administrador
     */
    public AdministradorJXTA getAdministrador() {
        return administrador;
    }

    /**
     * @param administrador the administrador to set
     */
    public void setAdministrador(AdministradorJXTA administrador) {
        this.administrador = administrador;
    }

    /**
     * @return the mapaOrd
     */
    public TreeMap<String,AdvertisementImagenImpl> getMapaOrd() {
        return mapaOrd;
    }

    /**
     * @param mapaOrd the mapaOrd to set
     */
    public void setMapaOrd(TreeMap<String,AdvertisementImagenImpl> mapaOrd) {
        this.mapaOrd = mapaOrd;
    }

    public void notificarObservadoresCambioEstado (Object obj){
        setChanged();
        notifyObservers(obj);
    }
}
